Im nächsten Schritt wollen wir noch einen weiteren Fallstrick besprechen, der auftreten

kann, sobald man nebenläufigen Zugriff auf Variablen hat.

In diesem Beispiel haben wir nun eine globale Variable Event, auf die ein Signalhändler

zugreift.

Diese ist initial auf den Wert 0 gesetzt und wird erst in der Signalbehandlung auf den

Wert 1 gesetzt.

Gleichzeitig haben wir eine Funktion WaitForEvent, die darauf wartet, dass sich die Variable

Event ändert.

Hier wird solange aktiv in einer Schleife gewartet, wie Event gleich 0 ist.

Und erst wenn die Signalbehandlung den Wert auf ungleich 0 setzt, kann die Schleife beendet

werden.

Wir gehen also davon aus, dass das Programm, das die Funktion WaitForEvent aufruft, solange

blockiert, bis das Signal, auf das gewartet wird, eingetroffen ist.

Das wollen wir jetzt mal testen, indem wir das Programm einmal kompilieren und ausführen.

Dabei werden wir verschiedene Optimierungen, die der Compiler bietet, einschalten.

Hier haben wir nun das Beispiel von eben, mit den beiden Funktionen Handle und WaitForEvent.

In Ergänzung haben wir nun noch eine Main-Funktion, in der die Signalbehandlung aufgesetzt wird

und die Funktion WaitForEvent ebenfalls aufgerufen wird.

Auf der rechten Seite sehen wir außerdem noch ein Makefile, mit dem ich nun das Programm

bauen werde.

Die Datei heißt test.c und ich versuche nun ein Programm test zu erstellen.

Dabei kompiliere ich es so, dass keine Optimierung angewandt wird.

Dies kann ich spezifizieren, indem ich dem Übersetzer die Option binnenstrich groß o

0 mitgebe.

Nun versuche ich das Programm auszuführen.

Aktuell scheint es in der Schleife zu warten.

In der Signalbehandlung sehen wir, dass das Programm auf das Eintreten des Signals SIGINT

wartet.

Dies können wir auslösen, indem wir Steuerung C drücken.

Und an dem Moment wurde die Signalbehandlung ausgeführt und die Variable Event auf 1

gesetzt.

Damit bricht das Programm in der WaitForEvent-Funktion in der Schleife aus.

Die Funktion kehrt also zurück und damit auch die Main-Funktion.

Nun versuche ich eine optimierte Variante zu bauen.

Dafür habe ich mir bereits ein Targeted Mac File vorbereitet.

In diesem Fall baue ich das Programm mit Optimierungen.

Dazu gebe ich die Option binnenstrich groß o 3 mit an den Übersetzer an.

Die Ausgabedatei heißt test.opt.

Diese versuche ich nun auszuführen.

Und wieder scheint das Programm in einer Endlosschleife zu sein.

Wenn ich nun versuche, Steuerung C zu drücken, um das SIGINT Signal abzuschicken, läuft

das Programm weiter.

Um das Programm nun zu terminieren, muss ich mir eine neue Kommandozeile öffnen und

das Programm über das Signal se kill töten.

Damit sehen wir, dass sich das Programm unterschiedlich verhält, je nachdem ob es einmal mit oder

ohne Optimierung gebaut wurde.

Im nächsten Schritt wollen wir uns also anschauen, was eigentlich der Unterschied zwischen den

beiden Optimierungsstufen ist.

Dazu wollen wir uns den Sampler Code anschauen.

Auch dafür habe ich bereits ein Target im Makefile angelegt.